package com.smartstate.dataManagement.service.impl;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.smartstate.dataManagement.dto.PageDTO;
import com.smartstate.dataManagement.entity.DeviceCarePlanEntity;
import com.smartstate.dataManagement.entity.Equipment;
import com.smartstate.dataManagement.entity.Role;
import com.smartstate.dataManagement.entity.User;
import com.smartstate.dataManagement.eunm.CommonEunm;
import com.smartstate.dataManagement.mapper.DeviceCarePlanMapper;
import com.smartstate.dataManagement.mapper.EquipmentMapper;
import com.smartstate.dataManagement.mapper.UserMapper;
import com.smartstate.dataManagement.service.DeviceCarePlanService;
import com.smartstate.dataManagement.util.DateTimeUtil;
import com.smartstate.dataManagement.util.StringUtils;
import com.smartstate.dataManagement.util.WrapperUtil;
import com.smartstate.dataManagement.vo.ResultVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


@Service
@Slf4j
public class DeviceCarePlanServiceImpl extends ServiceImpl<DeviceCarePlanMapper, DeviceCarePlanEntity>  implements DeviceCarePlanService {


    @Autowired
    DeviceCarePlanMapper deviceCarePlanMapper;

    @Autowired
    EquipmentMapper equipmentMapper;

    @Autowired
    UserMapper userMapper;
//
//    @Override
//    public Page<DeviceCarePlanEntity> getPlanByNameOrCode(PageDTO<DeviceCarePlanEntity> pageDTO) {
//
//        Page<DeviceCarePlanEntity>  page=new Page(pageDTO.getPages(),pageDTO.getSize());
//        List<DeviceCarePlanEntity>  deviceCarePlanEntityList=deviceCarePlanMapper.getPlanByNameOrCode(pageDTO.get.getDeviceName(),pageDTO.getDto().getDeviceId());
//        List<DeviceCarePlanEntity> list=handleDay(deviceCarePlanEntityList);
//        page.setTotal(deviceCarePlanEntityList.size());
//        page.setRecords(list);
//        return page;
//    }


    /**
     *
     * @Descripte :  处理保养时间倒计时
     *
     */
    public  List<DeviceCarePlanEntity>  handleDay(List<DeviceCarePlanEntity> list){
        List<DeviceCarePlanEntity> newList=new ArrayList<>();
        for(DeviceCarePlanEntity deviceCarePlanEntity:list){
            String currnTime=deviceCarePlanEntity.getCareTime().trim();
            if(StringUtils.isNotBlank(deviceCarePlanEntity.getCareCycle())) {
                int careyCycle = Integer.parseInt(deviceCarePlanEntity.getCareCycle());
                LocalDate careTieAddCycle = null;
                LocalDate careTime = DateTimeUtil.string2LocalDate(currnTime.substring(0, 10));
                LocalDate now = LocalDate.now();
                String day = Period.between(now, careTime).toString();
                // 是否超过保养时间
                if (day.contains("-")) {
                    careTieAddCycle = careTime.plusDays(careyCycle);
                    String day1 = Period.between(now, careTieAddCycle).toString();
                    deviceCarePlanEntity.setDay(day1.substring(day.indexOf(CommonEunm.P.getValue()) + 1, day1.indexOf(CommonEunm.D.getValue())));
                } else {
                    deviceCarePlanEntity.setDay(day.substring(day.indexOf(CommonEunm.P.getValue()) + 1, day.indexOf(CommonEunm.D.getValue())));
                }
                newList.add(deviceCarePlanEntity);
            }else{
                newList.add(deviceCarePlanEntity);
            }
        }
        return  newList;
    }



    @Override
    public ResultVO<Boolean> addPlan(String deviceName, String deviceCode,String planTime,String careCycle) {
        if(StringUtils.isNotBlank(deviceName) && StringUtils.isNotBlank(deviceCode) && StringUtils.isNotBlank(planTime)
                && StringUtils.isNotBlank(careCycle)){
            //TODO 获取当前的登录用户
            String username="测试员";
            //判断设备, 设备不为空
            Equipment equipment=equipmentMapper.getEquimentByCode(deviceCode);
            if(null!=equipment){
                if(deviceCarePlanMapper.addPlan(deviceCode,deviceName,CommonEunm.ZERO.getValue(),planTime,username,DateTimeUtil.localDateTime2String(LocalDateTime.now()),careCycle)>0){
                    return ResultVO.ok();
                }
                return  ResultVO.fail("新增失败");
            }
            return  ResultVO.fail("该设备不存在");
        }
        return  ResultVO.fail("参数缺失， 请输入参数");
    }


    @Override
    public Boolean deleteById(String id) {
        Boolean result =false;
        if(deviceCarePlanMapper.deleteById(id)>0){
            result=true;
        }
        return  result;
    }



    @Override
    public Boolean batchDelByIds(List<String> ids) {
        Boolean result =false;
        if(deviceCarePlanMapper.batchDelByIds(ids)>0){
            result=true;
        }
        return  result;
    }

    @Override
    public Boolean updateByID(DeviceCarePlanEntity deviceCarePlanEntity) {
        Boolean result =false;
        deviceCarePlanEntity.setUpdateTime(DateTimeUtil.localDateTime2String(LocalDateTime.now()));
        if(deviceCarePlanMapper.updateByID(deviceCarePlanEntity)>0){
            result=true;
        }
        return  result;
    }

    @Override
    public List<Equipment> getDeviceList(DeviceCarePlanEntity deviceCarePlanEntity) {
        return deviceCarePlanMapper.getDeviceList(deviceCarePlanEntity.getDeviceName());
    }

    @Override
    public Boolean editPlanByID(String id,String isAdd) {
        if(deviceCarePlanMapper.editPlanByID(id,isAdd)>0){
            return true;
        }
        return  false;
    }

    @Transactional
    public  boolean  handleDevicePlan(List<DeviceCarePlanEntity> newList,List<String> ids){
        // 开始批量新增数据 ( 需要同步执行）
        if(deviceCarePlanMapper.addBatchData(newList)>0){
            // 批量更新 之后更改原先的数据（ isAdd 为 1 ） 需求变更，将不在保存数据， 直接删除，
            if(deviceCarePlanMapper.deleteBatchIds(ids)>0){
                return  true;
            }
        }
        return  false;
    }

    @Override
    public Page<DeviceCarePlanEntity> queryAllPageByDTO(PageDTO pageDTO) {
        //关于设备保养时间到期时 ，根据设置的保养周期(必须先处理，否则数据不正确） ， 需要新增一条信息的保养数据 ， 并设置旧的设备保养的数据为已完成（不紧要）
        // TODO ,考虑到后期数据庞大， 数据处理费劲 所以大概率需要使用线程池的定时任务来处理。
        // todo , 考虑到服务宕机等问题 ， 数据不正确等问题， 由此需要使用数据库这种方式 （ 还需要研究）
        //创建查询语句包装器和分页查询表对象
        Page<DeviceCarePlanEntity> page = new Page(pageDTO.getPage(), pageDTO.getSize());
        //根据DTO注解封装查询语句
        DeviceCarePlanEntity dto = (DeviceCarePlanEntity) pageDTO.getDto();
        QueryWrapper<DeviceCarePlanEntity> wrapper = WrapperUtil.convertQuery(dto, DeviceCarePlanEntity.class);
        wrapper.orderByDesc("createTime");
        if(StringUtils.isNotBlank(dto.getDeviceName())){
            wrapper.like(CommonEunm.DEVICENAME.getValue(), dto.getDeviceName());
        }
        if(StringUtils.isNotBlank(dto.getDeviceId())){
            wrapper.like(CommonEunm.DEVICEID.getValue(), dto.getDeviceId());
        }
        // 只显示进行中的保养计划
//        wrapper.gt(CommonEunm.CARETIME.getValue(),new Date());
        // 查询的数据超过当前时间 （ 取消已经完成的和未完成的数据的筛选）
//        if(StringUtils.isNotBlank(dto.getState())){
//            if(CommonEunm.ZERO.getValue().equals(dto.getState())){
//                wrapper.lt(CommonEunm.CREATETIME.getValue(), new Date());
//            }
//            if(CommonEunm.ONE.getValue().equals(dto.getState())) {
//                wrapper.gt(CommonEunm.CREATETIME.getValue(), new Date());
//            }
//        }
        List<DeviceCarePlanEntity> list=baseMapper.selectPage(page,wrapper).getRecords();
        List<DeviceCarePlanEntity>  temp=handleDay(list);
        if(temp.size()>0){
        page.setRecords(temp);
        }else{
            page.setRecords(list);
        }
        //返回分页查询结果
        return page;
    }

}
